package service

import (
	"Data-API-MCP/backend/internal/domain/entity"
	"Data-API-MCP/backend/internal/domain/repository"
	"context"
	"database/sql"
	"errors"
	"fmt"
	"time"

	"github.com/gin-gonic/gin"
)

// APIService API服务接口
type APIService struct {
	apiRepo   repository.APIRepository
	dbService DBService
}

// NewAPIService 创建API服务实例
// @param apiRepo repository.APIRepository API仓库
// @param dbService DBService 数据库服务
// @return *APIService API服务实例
func NewAPIService(apiRepo repository.APIRepository, dbService DBService) *APIService {
	return &APIService{
		apiRepo:   apiRepo,
		dbService: dbService,
	}
}

// CreateAPI 创建API
func (s *APIService) CreateAPI(ctx context.Context, api *entity.API) error {
	api.CreatedAt = time.Now()
	api.UpdatedAt = time.Now()
	api.Status = 0 // 未发布状态
	return s.apiRepo.Create(ctx, api)
}

// UpdateAPI 更新API
func (s *APIService) UpdateAPI(ctx context.Context, api *entity.API) error {
	existingAPI, err := s.apiRepo.FindByID(ctx, api.ID)
	if err != nil {
		return errors.New("API不存在")
	}

	api.CreatedAt = existingAPI.CreatedAt
	api.UpdatedAt = time.Now()
	return s.apiRepo.Update(ctx, api)
}

// DeleteAPI 删除API
func (s *APIService) DeleteAPI(ctx context.Context, id string) error {
	return s.apiRepo.Delete(ctx, id)
}

// GetAPI 获取API
func (s *APIService) GetAPI(ctx context.Context, id string) (*entity.API, error) {
	return s.apiRepo.FindByID(ctx, id)
}

// ListAPIs 获取API列表
func (s *APIService) ListAPIs(ctx context.Context, offset, limit int) ([]*entity.API, error) {
	return s.apiRepo.List(ctx, offset, limit)
}

// CreateAPIVersion 创建API版本
func (s *APIService) CreateAPIVersion(ctx context.Context, version *entity.APIVersion) error {
	version.CreatedAt = time.Now()
	version.UpdatedAt = time.Now()
	version.Status = 0 // 草稿状态
	return s.apiRepo.CreateVersion(ctx, version)
}

// UpdateAPIVersion 更新API版本
func (s *APIService) UpdateAPIVersion(ctx context.Context, version *entity.APIVersion) error {
	existingVersion, err := s.apiRepo.FindVersionByID(ctx, version.ID)
	if err != nil {
		return errors.New("API版本不存在")
	}

	version.CreatedAt = existingVersion.CreatedAt
	version.UpdatedAt = time.Now()
	return s.apiRepo.UpdateVersion(ctx, version)
}

// DeleteAPIVersion 删除API版本
func (s *APIService) DeleteAPIVersion(ctx context.Context, id string) error {
	return s.apiRepo.DeleteVersion(ctx, id)
}

// GetAPIVersion 获取API版本
func (s *APIService) GetAPIVersion(ctx context.Context, id string) (*entity.APIVersion, error) {
	return s.apiRepo.FindVersionByID(ctx, id)
}

// ListAPIVersions 获取API版本列表
func (s *APIService) ListAPIVersions(ctx context.Context, apiID string) ([]*entity.APIVersion, error) {
	return s.apiRepo.ListVersions(ctx, apiID)
}

// CreateAPIDoc 创建API文档
func (s *APIService) CreateAPIDoc(ctx context.Context, doc *entity.APIDoc) error {
	doc.CreatedAt = time.Now()
	doc.UpdatedAt = time.Now()
	return s.apiRepo.CreateDoc(ctx, doc)
}

// UpdateAPIDoc 更新API文档
func (s *APIService) UpdateAPIDoc(ctx context.Context, doc *entity.APIDoc) error {
	existingDoc, err := s.apiRepo.FindDocByAPIID(ctx, doc.APIID)
	if err != nil {
		return errors.New("API文档不存在")
	}

	doc.CreatedAt = existingDoc.CreatedAt
	doc.UpdatedAt = time.Now()
	return s.apiRepo.UpdateDoc(ctx, doc)
}

// GetAPIDoc 获取API文档
func (s *APIService) GetAPIDoc(ctx context.Context, apiID string) (*entity.APIDoc, error) {
	return s.apiRepo.FindDocByAPIID(ctx, apiID)
}

// PublishAPI 发布API
func (s *APIService) PublishAPI(ctx context.Context, id string) error {
	return s.apiRepo.Publish(ctx, id)
}

// UnpublishAPI 取消发布API
func (s *APIService) UnpublishAPI(ctx context.Context, id string) error {
	return s.apiRepo.Unpublish(ctx, id)
}

// GetAPIsByService 获取服务下的API列表
func (s *APIService) GetAPIsByService(ctx context.Context, serviceID string) ([]*entity.API, error) {
	return s.apiRepo.FindByServiceID(ctx, serviceID)
}

// GetAPIsByConnection 获取指定连接的API列表
func (s *APIService) GetAPIsByConnection(ctx context.Context, connectionID string, offset, limit int) ([]*entity.API, error) {
	return s.apiRepo.ListByConnectionID(ctx, connectionID, offset, limit)
}

// TestAPI 测试API
func (s *APIService) TestAPI(ctx context.Context, id string, testData map[string]interface{}) (interface{}, error) {
	// 获取API信息
	api, err := s.apiRepo.FindByID(ctx, id)
	if err != nil {
		return nil, errors.New("API不存在")
	}

	// 获取API版本信息
	versions, err := s.apiRepo.ListVersions(ctx, id)
	if err != nil {
		return nil, errors.New("获取API版本失败")
	}

	// 获取最新的已发布版本
	var latestVersion *entity.APIVersion
	for _, v := range versions {
		if v.Status == 1 { // 已发布状态
			if latestVersion == nil || v.Version > latestVersion.Version {
				latestVersion = v
			}
		}
	}

	if latestVersion == nil {
		return nil, errors.New("API未发布任何版本")
	}

	// 获取数据库连接信息
	conn, err := s.dbService.GetConnection(ctx, api.ConnectionID)
	if err != nil {
		return nil, fmt.Errorf("获取数据库连接失败: %v", err)
	}

	// 构建数据库连接字符串
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s",
		conn.Username,
		conn.Password,
		conn.Host,
		conn.Port,
		conn.Database,
	)

	// 创建数据库连接
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, fmt.Errorf("创建数据库连接失败: %v", err)
	}
	defer db.Close()

	// 测试数据库连接
	if err := db.PingContext(ctx); err != nil {
		return nil, fmt.Errorf("数据库连接测试失败: %v", err)
	}

	// 创建SQL执行器
	executor := NewSQLExecutor(db)

	// 执行SQL
	result, err := executor.Execute(ctx, latestVersion.SQLContent, testData)
	if err != nil {
		return nil, fmt.Errorf("执行SQL失败: %v", err)
	}

	return gin.H{
		"api":       api,
		"version":   latestVersion,
		"test_data": testData,
		"result":    result,
	}, nil
}
